home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Misc / InstallerNG / developer / modules / prettyprinter / PerformAction.c < prev   
Encoding:
C/C++ Source or Header  |  2000-01-01  |  8.9 KB  |  312 lines
  1.  
  2. #include <installerngmodule_base.h>
  3.  
  4. #include <exec/types.h>
  5.  
  6. #include <clib/savage_protos.h>
  7. #include <clib/debuglib_protos.h>
  8.  
  9. #include <proto/dos.h>
  10.  
  11. #include <libraries/installerngmodule.h>
  12.  
  13. #include <dos/dos.h>
  14. #include <savage/macros.h>
  15.  
  16. /******************************************************************************/
  17.  
  18. static int tabs=0;
  19.  
  20. /******************************************************************************/
  21.  
  22. static void pp_Print(char *);
  23. static void pp_PrintF(char *, ULONG);
  24. static void pp_PrintTabs(void);
  25.  
  26. static BOOL pp_PrintTree(struct TreeNode *);
  27. static BOOL pp_PrintTreeList(struct List *);
  28. static BOOL pp_PrintTreeListTail(struct Node *);
  29.  
  30. static BOOL pp_PrintFunktion(struct TreeNode *);
  31. static BOOL pp_PrintExprlist(struct TreeNode *);
  32. static BOOL pp_PrintProcedure(struct TreeNode *);
  33. static BOOL pp_PrintIdent(char *);
  34. static BOOL pp_PrintString(char *);
  35. static BOOL pp_PrintNumber(long);
  36.  
  37. /******************************************************************************/
  38.  
  39. // the entry for this function call
  40. ULONG ingm_PerformAction(register __a0 struct ModuleEnvironment *me)
  41. {
  42.   // print the heade
  43.   pp_Print("\n\n/**\n");
  44.   pp_Print("*** this code was generated by the InstallerNG\n");
  45.   pp_Print("*** 'prettyprinter.module' -- done by savage\n");
  46.   pp_Print("**/\n\n");
  47.  
  48.   pp_Print("/*************************************************************/\n");
  49.   pp_Print("/* PROCEDURES                                                */\n");
  50.   pp_Print("/*************************************************************/\n\n");
  51.   pp_PrintTreeList(me->me_Procedures);
  52.  
  53.   pp_Print("\n/*************************************************************/\n");
  54.   pp_Print("/* ONERROR                                                   */\n");
  55.   pp_Print("/*************************************************************/\n\n");
  56.   pp_PrintTreeList(me->me_OnErrors);
  57.  
  58.   pp_Print("\n/*************************************************************/\n");
  59.   pp_Print("/* EFFECTS                                                   */\n");
  60.   pp_Print("/*************************************************************/\n\n");
  61.   pp_PrintTreeList(me->me_Effects);
  62.  
  63.   pp_Print("\n/*************************************************************/\n");
  64.   pp_Print("/* THE PROGRAM ITSELF                                        */\n");
  65.   pp_Print("/*************************************************************/\n\n");
  66.   pp_PrintTree(me->me_TreeRoot);
  67.  
  68.   pp_Print("\n\n\n");
  69.  
  70.   return 0L;
  71. }
  72.  
  73. /******************************************************************************/
  74.  
  75. // print a string
  76. static void pp_Print (char *str)
  77. {
  78.   pp_PrintF(str, NULL);
  79. }
  80.  
  81. static void pp_PrintF(char *str, ULONG args)
  82. {
  83.   KPrintF(str, args);
  84. }
  85.  
  86. static void pp_PrintTabs(void)
  87. {
  88.   int i;
  89.   for (i=0; i<tabs; i++) { pp_Print(" "); }
  90. }
  91.  
  92. /******************************************************************************/
  93.  
  94. static BOOL pp_PrintTreeList(struct List *list)
  95. {
  96.   return pp_PrintTreeListTail(sav_GetHead(list));
  97. }
  98.  
  99. /******************************************************************************/
  100.  
  101. static BOOL pp_PrintTreeListTail(struct Node *node)
  102. {
  103.   BOOL goon = TRUE;
  104.  
  105.   while (node && goon)
  106.   {
  107.     pp_Print(" ");
  108.  
  109.     goon = pp_PrintTree((struct TreeNode *) node);
  110.     node = sav_GetSucc(node);
  111.   }
  112.  
  113.   return goon;
  114. }
  115.  
  116. /******************************************************************************/
  117.  
  118. // print the tree; return false, if we want to break the rekursion
  119. static BOOL pp_PrintTree(struct TreeNode *node)
  120. {
  121.   BOOL goon = FALSE;
  122.  
  123.   // if there is enough free stack space, we go on traversing the tree
  124.   if (sav_StackLeft() < MINIMUM_FREE_STACKSPACE)
  125.   {
  126.     pp_Print("\n\n----> ERROR: NO FREE STACKSPACE LEFT <----\n\n");
  127.   }
  128.  
  129.   // check for user break
  130.   else if (SIGBREAKF_CTRL_C & CheckSignal(SIGBREAKF_CTRL_C))
  131.   {
  132.     pp_Print("\n\n----> USER BREAK BY CTRL-C <----\n\n");
  133.   }
  134.  
  135.   // look at the node type and call the print function for one specific node
  136.   else
  137.   {
  138.     switch (node->tn_Type)
  139.     {
  140.       case NODE_FUNCTION:   { goon = pp_PrintFunktion(node); break; }
  141.       case NODE_IDENT:      { goon = pp_PrintIdent(node->tn_Value.tnv_IdentName); break; }
  142.       case NODE_STRING:     { goon = pp_PrintString(node->tn_Value.tnv_String); break; }
  143.       case NODE_NUMBER:     { goon = pp_PrintNumber(node->tn_Value.tnv_Number); break; }
  144.  
  145.       case NODE_EXPRLIST:   { goon = pp_PrintExprlist(node); break; }
  146.       case NODE_FUNIDENT:   { goon = pp_PrintProcedure(node); break; }
  147.       case NODE_ROOT:       { goon = pp_PrintTreeList(&node->tn_Childs); break; }
  148.  
  149.       case NODE_FORMATSTR:
  150.       case NODE_FIRSTEXPR:  { goon = TRUE; break; }
  151.  
  152.       default:              { goon = TRUE; pp_Print("«UNKNOWN-NODE» "); }
  153.     }
  154.   }
  155.  
  156.   return goon;
  157. }
  158.  
  159. /******************************************************************************/
  160.  
  161. // print a function name
  162. static BOOL pp_PrintFunktion(struct TreeNode *node)
  163. {
  164.   BOOL goon = FALSE;
  165.  
  166.   static unsigned char *funnames[] =
  167.     { "ABORT", "COMPLETE", "COPYFILES", "COPYLIB", "DEBUG", "DELETE",
  168.       "EXECUTE", "EXIT", "FOREACH", "MAKEASSIGN", "MAKEDIR", "MESSAGE",
  169.       "ONERROR", "PROCEDURE", "PROTECT", "RENAME", "REXX", "RUN", "SET",
  170.       "STARTUP", "TEXTFILE", "TOOLTYPE", "TRAP", "USER", "WELCOME",
  171.       "WORKING", "IF", "UNTIL", "WHILE", "EQU", "NE", "GT", "GE", "LT",
  172.       "LE", "+", "-", "*", "/", "AND", "OR", "XOR", "NOT",
  173.       "BITAND", "BITOR", "BITXOR", "BITNOT", "SHIFTLEFT", "SHIFTRIGHT",
  174.       "IN", "ASKDIR", "ASKFILE", "ASKSTRING", "ASKNUMBER", "ASKCHOICE",
  175.       "ASKOPTIONS", "ASKBOOL", "ASKDISK", "CAT", "DATABASE", "EXISTS",
  176.       "EXPANDPATH", "EARLIER", "FILEONLY", "GETASSIGN", "GETDEVICE",
  177.       "GETDISKSPACE", "GETENV", "GETSIZE", "GETSUM", "GETVERSION",
  178.       "PATHONLY", "PATMATCH", "SELECT", "STRLEN", "SUBSTR", "TRANSCRIPT",
  179.       "TACKON", "ALL", "APPEND", "ASSIGNS", "CHOICES", "COMMAND", "CONFIRM",
  180.       "DEFAULT", "DELOPTS", "DEST", "DISK", "FILES", "FONTS", "HELP",
  181.       "INCLUDE", "INFOS", "NEWNAME", "NEWPATH", "NOGAUGE", "NOPOSITION",
  182.       "NOREQ", "OPTIONAL", "PATTERN", "PROMPT", "QUIET", "RANGE",
  183.       "RESIDENT", "SAFE", "SETDEFAULTTOOL", "SETSTACK", "SETTOOLTYPE",
  184.       "SOURCE", "SWAPCOLORS", "SYMBOLSET", "SYMBOLVAL", "ICONINFO",
  185.       "SETPOSITION", "GETTOOLTYPE", "GETDEFAULTTOOL", "GETSTACK",
  186.       "GETPOSITION", "SIMULATE-ERROR", "BEEP", "COMPARE", "FINDBOARD",
  187.       "LET", "REBOOT", "DELAY", "SWING", "RANDOM", "PUT-PROPERTY",
  188.       "GET-PROPERTY", "REMOVE-PROPERTY", "SAFE-PROPERTY-OBJECT",
  189.       "READ-PROPERTY-OBJECT", "CAST-INT", "CAST-STRING", "NOP", "FLUSHLIBS",
  190.       "EFFECT", "SHOWMEDIA", "SETMEDIA", "CLOSEMEDIA", "TRACE", "RETRACE",
  191.       "QUERYDISPLAY","BACK", "OPENWBOBJECT", "SHOWWBOBJECT", "CLOSEWBOBJECT",
  192.       "SETENV" };
  193.  
  194.   pp_Print("\n");
  195.   pp_PrintTabs();
  196.   pp_Print("(");
  197.   pp_Print(funnames[node->tn_Value.tnv_FunID-1]);
  198.  
  199.   // dont forget a nodes childes
  200.   if (0 == sav_ListLen((struct List *) &node->tn_Childs)) { }
  201.   else
  202.   {
  203.     tabs += 2;
  204.     goon = pp_PrintTreeList((struct List *) &node->tn_Childs);
  205.     tabs -= 2;
  206.   }
  207.  
  208.   pp_Print(")");
  209.  
  210.   return TRUE;
  211. }
  212.  
  213. /******************************************************************************/
  214.  
  215. //
  216. static BOOL pp_PrintExprlist(struct TreeNode *node)
  217. {
  218.   BOOL goon;
  219.  
  220.   pp_Print("\n");
  221.   pp_PrintTabs();
  222.   pp_Print("(");
  223.  
  224.   tabs += 2;
  225.   goon = pp_PrintTreeList((struct List *) &node->tn_Childs);
  226.   tabs -= 2;
  227.  
  228.   pp_Print("\n");
  229.   pp_PrintTabs();
  230.   pp_Print(")");
  231.  
  232.   return goon;
  233. }
  234.  
  235. /******************************************************************************/
  236.  
  237. // print an ident name
  238. static BOOL pp_PrintIdent(char *idname)
  239. {
  240.   pp_Print(idname);
  241.  
  242.   return TRUE;
  243. }
  244.  
  245. /******************************************************************************/
  246.  
  247. // print a procedure name
  248. static BOOL pp_PrintProcedure(struct TreeNode *node)
  249. {
  250.   BOOL goon;
  251.  
  252.   pp_Print("\n");
  253.   pp_PrintTabs();
  254.   pp_Print("(");
  255.   pp_Print(node->tn_Value.tnv_IdentName);
  256.  
  257.   // dont forget a nodes childes
  258.   if (0 == sav_ListLen((struct List *) &node->tn_Childs)) { }
  259.   else
  260.   {
  261.     tabs += 2;
  262.     goon = pp_PrintTreeList((struct List *) &node->tn_Childs);
  263.     tabs -= 2;
  264.   }
  265.  
  266.   pp_Print(")\n");
  267.  
  268.   return goon;
  269. }
  270.  
  271. /******************************************************************************/
  272.  
  273. // print a string
  274. static BOOL pp_PrintString(char *str)
  275. {
  276.   unsigned char chrs[] = { 0, 0 };
  277.  
  278.   pp_Print("\"");
  279.  
  280.   while (chrs[0] = *str++)
  281.   {
  282.     switch (chrs[0])
  283.     {
  284.       case    0:  { pp_Print("\\0"); break; }
  285.       case    8:  { pp_Print("\\b"); break; }
  286.       case    9:  { pp_Print("\\t"); break; }
  287.       case   10:  { pp_Print("\\n"); break; }
  288.       case   11:  { pp_Print("\\v"); break; }
  289.       case   12:  { pp_Print("\\f"); break; }
  290.       case   13:  { pp_Print("\\r"); break; }
  291.       case  '"':  { pp_Print("\\\""); break; }
  292.       case '\\':  { pp_Print("\\\\"); break; }
  293.       default:    { pp_Print((char *) &chrs); }
  294.     }
  295.   }
  296.  
  297.   pp_Print("\"");
  298.  
  299.   return TRUE;
  300. }
  301.  
  302. /******************************************************************************/
  303.  
  304. // print a number
  305. static BOOL pp_PrintNumber(long num)
  306. {
  307.   pp_PrintF("%ld", (ULONG) num);
  308.  
  309.   return TRUE;
  310. }
  311.  
  312.